package practica3;

public class Septima {
	/*
	* Devuelve el numero de objetos referenciados por los elementos de la tabla [T]. La
	* dimension de la tabla [T] es mayor que cero
	*/
	public static <Dato> int numObjetos (Dato[] T){
		return T.length;		
	}
	/*
	* Permuta los datos de [C] de forma que el primero de los objetos pase a ser el ultimo , el
	* segundo pase a ser el penultimo , el tercero pase a ser el antepen ultimo y ası sucesivamente
	* hasta que el penultimo pase a ser el segundo y el ultimo pase a ser el primero
	*/
	public static <C> void cambiarOrden (C[] T){
		cambiarOrden(T,0);
	}
	private static <C> void cambiarOrden (C[] T,int i){
		C aux;
		if (i< T.length/2){
			aux=T[i];
			T[i]=T[T.length-1-i];
			T[T.length-1-i]=aux;
			cambiarOrden(T,i+1);
		}
	}
	/*
	* Devuelve el numero de objetos referenciados desde la tabla [T] cuyo contenido es identico
	* al del objeto referenciado por [dato ]. La dimension de la tabla [T] es mayor que cero
	*/
	public static <D> int sonIguales (D[] T, D dato){
		return sonIguales(T,dato,0,0);
	}
	private static <D> int sonIguales (D[] T, D dato,int i,int n){
		if (i==T.length-1){
			return n;
		}
		else{
			if (T[i].equals(dato)){n++;}
			i++;
			return sonIguales(T,dato,i,n);
		}			
	}
	/*
	* La tabla [T] tiene dimension mayor que 0 y no almacena referencias null . Devuelve [true ] si
	* y solo si los objetos referenciados desde [T] estan ordenados de menor a mayor valor segun
	* el criterio de comparacion implementado en el metodo compareTo(C) de la clase [C] ´
	*/
	public static <C extends Comparable <C>> boolean estaOrdenada (C[] T){		
		return estaOrdenada(T,0);		
	}
	private static <C extends Comparable <C>> boolean estaOrdenada (C[] T,int i){
		if (i==T.length-2){
			if (T[i].compareTo(T[i+1])<=0){
				return true;
			}
			else {return false;}
		}
		else {
			if (T[i].compareTo(T[i+1])<=0){
				return estaOrdenada(T,1+i);
			}
			else {return false;}
		}
	}
	/*
	* Elimina de la tabla [T] todas las referencias a objetos T[i] menores que el objeto
	* referenciado por [d] segun el criterio de comparación implementado en el metodo
	* compareTo(Dato) de la clase [Dato]; dichas referencias pasan a tener valor [ null ]. Las
	* restantes referencias de la tabla quedan inalteradas . La dimension de la tabla [T]
	* es mayor que cero
	*/
	public static <Dato extends Comparable <Dato>> void eliminarMenores (Dato[] T, Dato d){
		eliminarMenores(T,d,0);		
	}
	private static <Dato extends Comparable <Dato>> void eliminarMenores (Dato[] T, Dato d,int i){
		if (i==T.length-1){
			if (T[i].compareTo(d)<0){
				T[i]=null;
			}
		}
		else {
			if (T[i].compareTo(d)<0){
				T[i]=null;
			}
			eliminarMenores(T,d,i+1);
		}
	}
	public static void main (String[] argumentos) {
		Integer T[] = new Integer[5];
		T[0]=(1);T[1]=(1);T[2]=(1);T[3]=(0);T[4]=(6);
		System.out.println(sonIguales(T,0));		//Comparo con el 0
		System.out.println(estaOrdenada(T));		
	}
	

	
		
}